home *** CD-ROM | disk | FTP | other *** search
/ Champak 141 / (Vol 141) Oct 17 2011.iso / Games / despereaux-swings.swf / scripts / Box2D / Collision / Shapes / b2PolygonShape.as < prev    next >
Encoding:
Text File  |  2011-10-17  |  19.3 KB  |  531 lines
  1. package Box2D.Collision.Shapes
  2. {
  3.    import Box2D.Collision.*;
  4.    import Box2D.Common.*;
  5.    import Box2D.Common.Math.*;
  6.    import Box2D.Dynamics.*;
  7.    
  8.    public class b2PolygonShape extends b2Shape
  9.    {
  10.       
  11.       private static var s_computeMat:b2Mat22 = new b2Mat22();
  12.       
  13.       private static var s_sweptAABB1:b2AABB = new b2AABB();
  14.       
  15.       private static var s_sweptAABB2:b2AABB = new b2AABB();
  16.        
  17.       
  18.       public var m_vertices:Array;
  19.       
  20.       public var m_normals:Array;
  21.       
  22.       private var s_supportVec:b2Vec2;
  23.       
  24.       public var m_obb:b2OBB;
  25.       
  26.       public var m_coreVertices:Array;
  27.       
  28.       public var m_centroid:b2Vec2;
  29.       
  30.       public var m_vertexCount:int;
  31.       
  32.       public function b2PolygonShape(param1:b2ShapeDef)
  33.       {
  34.          var _loc2_:b2PolygonDef = null;
  35.          var _loc3_:int = 0;
  36.          var _loc4_:int = 0;
  37.          var _loc5_:int = 0;
  38.          var _loc6_:Number = NaN;
  39.          var _loc7_:Number = NaN;
  40.          var _loc8_:Number = NaN;
  41.          var _loc9_:Number = NaN;
  42.          var _loc10_:Number = NaN;
  43.          var _loc11_:Number = NaN;
  44.          var _loc12_:Number = NaN;
  45.          var _loc13_:Number = NaN;
  46.          var _loc14_:Number = NaN;
  47.          var _loc15_:Number = NaN;
  48.          var _loc16_:Number = NaN;
  49.          var _loc17_:Number = NaN;
  50.          s_supportVec = new b2Vec2();
  51.          m_obb = new b2OBB();
  52.          m_vertices = new Array(b2Settings.b2_maxPolygonVertices);
  53.          m_normals = new Array(b2Settings.b2_maxPolygonVertices);
  54.          m_coreVertices = new Array(b2Settings.b2_maxPolygonVertices);
  55.          super(param1);
  56.          m_type = e_polygonShape;
  57.          _loc2_ = param1 as b2PolygonDef;
  58.          m_vertexCount = _loc2_.vertexCount;
  59.          _loc4_ = _loc3_;
  60.          _loc5_ = _loc3_;
  61.          _loc3_ = 0;
  62.          while(_loc3_ < m_vertexCount)
  63.          {
  64.             m_vertices[_loc3_] = _loc2_.vertices[_loc3_].Copy();
  65.             _loc3_++;
  66.          }
  67.          _loc3_ = 0;
  68.          while(_loc3_ < m_vertexCount)
  69.          {
  70.             _loc4_ = _loc3_;
  71.             _loc5_ = _loc3_ + 1 < m_vertexCount ? _loc3_ + 1 : 0;
  72.             _loc6_ = m_vertices[_loc5_].x - m_vertices[_loc4_].x;
  73.             _loc7_ = m_vertices[_loc5_].y - m_vertices[_loc4_].y;
  74.             _loc8_ = Math.sqrt(_loc6_ * _loc6_ + _loc7_ * _loc7_);
  75.             m_normals[_loc3_] = new b2Vec2(_loc7_ / _loc8_,-_loc6_ / _loc8_);
  76.             _loc3_++;
  77.          }
  78.          m_centroid = ComputeCentroid(_loc2_.vertices,_loc2_.vertexCount);
  79.          ComputeOBB(m_obb,m_vertices,m_vertexCount);
  80.          _loc3_ = 0;
  81.          while(_loc3_ < m_vertexCount)
  82.          {
  83.             _loc4_ = _loc3_ - 1 >= 0 ? _loc3_ - 1 : m_vertexCount - 1;
  84.             _loc5_ = _loc3_;
  85.             _loc9_ = Number(m_normals[_loc4_].x);
  86.             _loc10_ = Number(m_normals[_loc4_].y);
  87.             _loc11_ = Number(m_normals[_loc5_].x);
  88.             _loc12_ = Number(m_normals[_loc5_].y);
  89.             _loc13_ = m_vertices[_loc3_].x - m_centroid.x;
  90.             _loc14_ = m_vertices[_loc3_].y - m_centroid.y;
  91.             _loc15_ = _loc9_ * _loc13_ + _loc10_ * _loc14_ - b2Settings.b2_toiSlop;
  92.             _loc16_ = _loc11_ * _loc13_ + _loc12_ * _loc14_ - b2Settings.b2_toiSlop;
  93.             _loc17_ = 1 / (_loc9_ * _loc12_ - _loc10_ * _loc11_);
  94.             m_coreVertices[_loc3_] = new b2Vec2(_loc17_ * (_loc12_ * _loc15_ - _loc10_ * _loc16_) + m_centroid.x,_loc17_ * (_loc9_ * _loc16_ - _loc11_ * _loc15_) + m_centroid.y);
  95.             _loc3_++;
  96.          }
  97.       }
  98.       
  99.       public static function ComputeCentroid(param1:Array, param2:int) : b2Vec2
  100.       {
  101.          var _loc3_:b2Vec2 = null;
  102.          var _loc4_:Number = NaN;
  103.          var _loc5_:Number = NaN;
  104.          var _loc6_:Number = NaN;
  105.          var _loc7_:Number = NaN;
  106.          var _loc8_:int = 0;
  107.          var _loc9_:b2Vec2 = null;
  108.          var _loc10_:b2Vec2 = null;
  109.          var _loc11_:Number = NaN;
  110.          var _loc12_:Number = NaN;
  111.          var _loc13_:Number = NaN;
  112.          var _loc14_:Number = NaN;
  113.          var _loc15_:Number = NaN;
  114.          var _loc16_:Number = NaN;
  115.          _loc3_ = new b2Vec2();
  116.          _loc4_ = 0;
  117.          _loc5_ = 0;
  118.          _loc6_ = 0;
  119.          _loc7_ = 1 / 3;
  120.          _loc8_ = 0;
  121.          while(_loc8_ < param2)
  122.          {
  123.             _loc9_ = param1[_loc8_];
  124.             _loc10_ = _loc8_ + 1 < param2 ? param1[int(_loc8_ + 1)] : param1[0];
  125.             _loc11_ = _loc9_.x - _loc5_;
  126.             _loc12_ = _loc9_.y - _loc6_;
  127.             _loc13_ = _loc10_.x - _loc5_;
  128.             _loc14_ = _loc10_.y - _loc6_;
  129.             _loc15_ = _loc11_ * _loc14_ - _loc12_ * _loc13_;
  130.             _loc16_ = 0.5 * _loc15_;
  131.             _loc4_ += _loc16_;
  132.             _loc3_.x += _loc16_ * _loc7_ * (_loc5_ + _loc9_.x + _loc10_.x);
  133.             _loc3_.y += _loc16_ * _loc7_ * (_loc6_ + _loc9_.y + _loc10_.y);
  134.             _loc8_++;
  135.          }
  136.          _loc3_.x *= 1 / _loc4_;
  137.          _loc3_.y *= 1 / _loc4_;
  138.          return _loc3_;
  139.       }
  140.       
  141.       public static function ComputeOBB(param1:b2OBB, param2:Array, param3:int) : void
  142.       {
  143.          var _loc4_:int = 0;
  144.          var _loc5_:Array = null;
  145.          var _loc6_:Number = NaN;
  146.          var _loc7_:b2Vec2 = null;
  147.          var _loc8_:Number = NaN;
  148.          var _loc9_:Number = NaN;
  149.          var _loc10_:Number = NaN;
  150.          var _loc11_:Number = NaN;
  151.          var _loc12_:Number = NaN;
  152.          var _loc13_:Number = NaN;
  153.          var _loc14_:Number = NaN;
  154.          var _loc15_:Number = NaN;
  155.          var _loc16_:Number = NaN;
  156.          var _loc17_:int = 0;
  157.          var _loc18_:Number = NaN;
  158.          var _loc19_:Number = NaN;
  159.          var _loc20_:Number = NaN;
  160.          var _loc21_:Number = NaN;
  161.          var _loc22_:Number = NaN;
  162.          var _loc23_:Number = NaN;
  163.          var _loc24_:Number = NaN;
  164.          var _loc25_:b2Mat22 = null;
  165.          _loc5_ = new Array(b2Settings.b2_maxPolygonVertices + 1);
  166.          _loc4_ = 0;
  167.          while(_loc4_ < param3)
  168.          {
  169.             _loc5_[_loc4_] = param2[_loc4_];
  170.             _loc4_++;
  171.          }
  172.          _loc5_[param3] = _loc5_[0];
  173.          _loc6_ = Number.MAX_VALUE;
  174.          _loc4_ = 1;
  175.          while(_loc4_ <= param3)
  176.          {
  177.             _loc7_ = _loc5_[int(_loc4_ - 1)];
  178.             _loc8_ = _loc5_[_loc4_].x - _loc7_.x;
  179.             _loc9_ = _loc5_[_loc4_].y - _loc7_.y;
  180.             _loc10_ = Math.sqrt(_loc8_ * _loc8_ + _loc9_ * _loc9_);
  181.             _loc8_ /= _loc10_;
  182.             _loc11_ = -(_loc9_ /= _loc10_);
  183.             _loc12_ = _loc8_;
  184.             _loc13_ = Number.MAX_VALUE;
  185.             _loc14_ = Number.MAX_VALUE;
  186.             _loc15_ = -Number.MAX_VALUE;
  187.             _loc16_ = -Number.MAX_VALUE;
  188.             _loc17_ = 0;
  189.             while(_loc17_ < param3)
  190.             {
  191.                _loc19_ = _loc5_[_loc17_].x - _loc7_.x;
  192.                _loc20_ = _loc5_[_loc17_].y - _loc7_.y;
  193.                _loc21_ = _loc8_ * _loc19_ + _loc9_ * _loc20_;
  194.                _loc22_ = _loc11_ * _loc19_ + _loc12_ * _loc20_;
  195.                if(_loc21_ < _loc13_)
  196.                {
  197.                   _loc13_ = _loc21_;
  198.                }
  199.                if(_loc22_ < _loc14_)
  200.                {
  201.                   _loc14_ = _loc22_;
  202.                }
  203.                if(_loc21_ > _loc15_)
  204.                {
  205.                   _loc15_ = _loc21_;
  206.                }
  207.                if(_loc22_ > _loc16_)
  208.                {
  209.                   _loc16_ = _loc22_;
  210.                }
  211.                _loc17_++;
  212.             }
  213.             if((_loc18_ = (_loc15_ - _loc13_) * (_loc16_ - _loc14_)) < 0.95 * _loc6_)
  214.             {
  215.                _loc6_ = _loc18_;
  216.                param1.R.col1.x = _loc8_;
  217.                param1.R.col1.y = _loc9_;
  218.                param1.R.col2.x = _loc11_;
  219.                param1.R.col2.y = _loc12_;
  220.                _loc23_ = 0.5 * (_loc13_ + _loc15_);
  221.                _loc24_ = 0.5 * (_loc14_ + _loc16_);
  222.                _loc25_ = param1.R;
  223.                param1.center.x = _loc7_.x + (_loc25_.col1.x * _loc23_ + _loc25_.col2.x * _loc24_);
  224.                param1.center.y = _loc7_.y + (_loc25_.col1.y * _loc23_ + _loc25_.col2.y * _loc24_);
  225.                param1.extents.x = 0.5 * (_loc15_ - _loc13_);
  226.                param1.extents.y = 0.5 * (_loc16_ - _loc14_);
  227.             }
  228.             _loc4_++;
  229.          }
  230.       }
  231.       
  232.       override public function TestPoint(param1:b2XForm, param2:b2Vec2) : Boolean
  233.       {
  234.          var _loc3_:b2Vec2 = null;
  235.          var _loc4_:b2Mat22 = null;
  236.          var _loc5_:Number = NaN;
  237.          var _loc6_:Number = NaN;
  238.          var _loc7_:Number = NaN;
  239.          var _loc8_:Number = NaN;
  240.          var _loc9_:int = 0;
  241.          var _loc10_:Number = NaN;
  242.          _loc4_ = param1.R;
  243.          _loc5_ = param2.x - param1.position.x;
  244.          _loc6_ = param2.y - param1.position.y;
  245.          _loc7_ = _loc5_ * _loc4_.col1.x + _loc6_ * _loc4_.col1.y;
  246.          _loc8_ = _loc5_ * _loc4_.col2.x + _loc6_ * _loc4_.col2.y;
  247.          _loc9_ = 0;
  248.          while(_loc9_ < m_vertexCount)
  249.          {
  250.             _loc3_ = m_vertices[_loc9_];
  251.             _loc5_ = _loc7_ - _loc3_.x;
  252.             _loc6_ = _loc8_ - _loc3_.y;
  253.             _loc3_ = m_normals[_loc9_];
  254.             if((_loc10_ = _loc3_.x * _loc5_ + _loc3_.y * _loc6_) > 0)
  255.             {
  256.                return false;
  257.             }
  258.             _loc9_++;
  259.          }
  260.          return true;
  261.       }
  262.       
  263.       public function GetCoreVertices() : Array
  264.       {
  265.          return m_coreVertices;
  266.       }
  267.       
  268.       override public function TestSegment(param1:b2XForm, param2:Array, param3:b2Vec2, param4:b2Segment, param5:Number) : Boolean
  269.       {
  270.          var _loc6_:Number = NaN;
  271.          var _loc7_:Number = NaN;
  272.          var _loc8_:Number = NaN;
  273.          var _loc9_:Number = NaN;
  274.          var _loc10_:b2Mat22 = null;
  275.          var _loc11_:b2Vec2 = null;
  276.          var _loc12_:Number = NaN;
  277.          var _loc13_:Number = NaN;
  278.          var _loc14_:Number = NaN;
  279.          var _loc15_:Number = NaN;
  280.          var _loc16_:Number = NaN;
  281.          var _loc17_:Number = NaN;
  282.          var _loc18_:int = 0;
  283.          var _loc19_:int = 0;
  284.          var _loc20_:Number = NaN;
  285.          var _loc21_:Number = NaN;
  286.          _loc6_ = 0;
  287.          _loc7_ = param5;
  288.          _loc8_ = param4.p1.x - param1.position.x;
  289.          _loc9_ = param4.p1.y - param1.position.y;
  290.          _loc10_ = param1.R;
  291.          _loc12_ = _loc8_ * _loc10_.col1.x + _loc9_ * _loc10_.col1.y;
  292.          _loc13_ = _loc8_ * _loc10_.col2.x + _loc9_ * _loc10_.col2.y;
  293.          _loc8_ = param4.p2.x - param1.position.x;
  294.          _loc9_ = param4.p2.y - param1.position.y;
  295.          _loc10_ = param1.R;
  296.          _loc14_ = _loc8_ * _loc10_.col1.x + _loc9_ * _loc10_.col1.y;
  297.          _loc15_ = _loc8_ * _loc10_.col2.x + _loc9_ * _loc10_.col2.y;
  298.          _loc16_ = _loc14_ - _loc12_;
  299.          _loc17_ = _loc15_ - _loc13_;
  300.          _loc18_ = -1;
  301.          _loc19_ = 0;
  302.          while(_loc19_ < m_vertexCount)
  303.          {
  304.             _loc8_ = (_loc11_ = m_vertices[_loc19_]).x - _loc12_;
  305.             _loc9_ = _loc11_.y - _loc13_;
  306.             _loc20_ = (_loc11_ = m_normals[_loc19_]).x * _loc8_ + _loc11_.y * _loc9_;
  307.             if((_loc21_ = _loc11_.x * _loc16_ + _loc11_.y * _loc17_) < 0 && _loc20_ < _loc6_ * _loc21_)
  308.             {
  309.                _loc6_ = _loc20_ / _loc21_;
  310.                _loc18_ = _loc19_;
  311.             }
  312.             else if(_loc21_ > 0 && _loc20_ < _loc7_ * _loc21_)
  313.             {
  314.                _loc7_ = _loc20_ / _loc21_;
  315.             }
  316.             if(_loc7_ < _loc6_)
  317.             {
  318.                return false;
  319.             }
  320.             _loc19_++;
  321.          }
  322.          if(_loc18_ >= 0)
  323.          {
  324.             param2[0] = _loc6_;
  325.             _loc10_ = param1.R;
  326.             _loc11_ = m_normals[_loc18_];
  327.             param3.x = _loc10_.col1.x * _loc11_.x + _loc10_.col2.x * _loc11_.y;
  328.             param3.y = _loc10_.col1.y * _loc11_.x + _loc10_.col2.y * _loc11_.y;
  329.             return true;
  330.          }
  331.          return false;
  332.       }
  333.       
  334.       public function GetCentroid() : b2Vec2
  335.       {
  336.          return m_centroid;
  337.       }
  338.       
  339.       override public function ComputeMass(param1:b2MassData) : void
  340.       {
  341.          var _loc2_:Number = NaN;
  342.          var _loc3_:Number = NaN;
  343.          var _loc4_:Number = NaN;
  344.          var _loc5_:Number = NaN;
  345.          var _loc6_:Number = NaN;
  346.          var _loc7_:Number = NaN;
  347.          var _loc8_:Number = NaN;
  348.          var _loc9_:int = 0;
  349.          var _loc10_:b2Vec2 = null;
  350.          var _loc11_:b2Vec2 = null;
  351.          var _loc12_:Number = NaN;
  352.          var _loc13_:Number = NaN;
  353.          var _loc14_:Number = NaN;
  354.          var _loc15_:Number = NaN;
  355.          var _loc16_:Number = NaN;
  356.          var _loc17_:Number = NaN;
  357.          var _loc18_:Number = NaN;
  358.          var _loc19_:Number = NaN;
  359.          var _loc20_:Number = NaN;
  360.          var _loc21_:Number = NaN;
  361.          var _loc22_:Number = NaN;
  362.          var _loc23_:Number = NaN;
  363.          var _loc24_:Number = NaN;
  364.          var _loc25_:Number = NaN;
  365.          _loc2_ = 0;
  366.          _loc3_ = 0;
  367.          _loc4_ = 0;
  368.          _loc5_ = 0;
  369.          _loc6_ = 0;
  370.          _loc7_ = 0;
  371.          _loc8_ = 1 / 3;
  372.          _loc9_ = 0;
  373.          while(_loc9_ < m_vertexCount)
  374.          {
  375.             _loc10_ = m_vertices[_loc9_];
  376.             _loc11_ = _loc9_ + 1 < m_vertexCount ? m_vertices[int(_loc9_ + 1)] : m_vertices[0];
  377.             _loc12_ = _loc10_.x - _loc6_;
  378.             _loc13_ = _loc10_.y - _loc7_;
  379.             _loc14_ = _loc11_.x - _loc6_;
  380.             _loc15_ = _loc11_.y - _loc7_;
  381.             _loc16_ = _loc12_ * _loc15_ - _loc13_ * _loc14_;
  382.             _loc17_ = 0.5 * _loc16_;
  383.             _loc4_ += _loc17_;
  384.             _loc2_ += _loc17_ * _loc8_ * (_loc6_ + _loc10_.x + _loc11_.x);
  385.             _loc3_ += _loc17_ * _loc8_ * (_loc7_ + _loc10_.y + _loc11_.y);
  386.             _loc18_ = _loc6_;
  387.             _loc19_ = _loc7_;
  388.             _loc20_ = _loc12_;
  389.             _loc21_ = _loc13_;
  390.             _loc22_ = _loc14_;
  391.             _loc23_ = _loc15_;
  392.             _loc24_ = _loc8_ * (0.25 * (_loc20_ * _loc20_ + _loc22_ * _loc20_ + _loc22_ * _loc22_) + (_loc18_ * _loc20_ + _loc18_ * _loc22_)) + 0.5 * _loc18_ * _loc18_;
  393.             _loc25_ = _loc8_ * (0.25 * (_loc21_ * _loc21_ + _loc23_ * _loc21_ + _loc23_ * _loc23_) + (_loc19_ * _loc21_ + _loc19_ * _loc23_)) + 0.5 * _loc19_ * _loc19_;
  394.             _loc5_ += _loc16_ * (_loc24_ + _loc25_);
  395.             _loc9_++;
  396.          }
  397.          param1.mass = m_density * _loc4_;
  398.          _loc2_ *= 1 / _loc4_;
  399.          _loc3_ *= 1 / _loc4_;
  400.          param1.center.Set(_loc2_,_loc3_);
  401.          param1.I = m_density * _loc5_;
  402.       }
  403.       
  404.       public function Support(param1:b2XForm, param2:Number, param3:Number) : b2Vec2
  405.       {
  406.          var _loc4_:b2Vec2 = null;
  407.          var _loc5_:b2Mat22 = null;
  408.          var _loc6_:Number = NaN;
  409.          var _loc7_:Number = NaN;
  410.          var _loc8_:int = 0;
  411.          var _loc9_:Number = NaN;
  412.          var _loc10_:int = 0;
  413.          var _loc11_:Number = NaN;
  414.          _loc5_ = param1.R;
  415.          _loc6_ = param2 * _loc5_.col1.x + param3 * _loc5_.col1.y;
  416.          _loc7_ = param2 * _loc5_.col2.x + param3 * _loc5_.col2.y;
  417.          _loc8_ = 0;
  418.          _loc9_ = (_loc4_ = m_coreVertices[0]).x * _loc6_ + _loc4_.y * _loc7_;
  419.          _loc10_ = 1;
  420.          while(_loc10_ < m_vertexCount)
  421.          {
  422.             if((_loc11_ = (_loc4_ = m_coreVertices[_loc10_]).x * _loc6_ + _loc4_.y * _loc7_) > _loc9_)
  423.             {
  424.                _loc8_ = _loc10_;
  425.                _loc9_ = _loc11_;
  426.             }
  427.             _loc10_++;
  428.          }
  429.          _loc5_ = param1.R;
  430.          _loc4_ = m_coreVertices[_loc8_];
  431.          s_supportVec.x = param1.position.x + (_loc5_.col1.x * _loc4_.x + _loc5_.col2.x * _loc4_.y);
  432.          s_supportVec.y = param1.position.y + (_loc5_.col1.y * _loc4_.x + _loc5_.col2.y * _loc4_.y);
  433.          return s_supportVec;
  434.       }
  435.       
  436.       public function GetVertexCount() : int
  437.       {
  438.          return m_vertexCount;
  439.       }
  440.       
  441.       override public function ComputeSweptAABB(param1:b2AABB, param2:b2XForm, param3:b2XForm) : void
  442.       {
  443.          var _loc4_:b2AABB = null;
  444.          var _loc5_:b2AABB = null;
  445.          _loc4_ = s_sweptAABB1;
  446.          _loc5_ = s_sweptAABB2;
  447.          ComputeAABB(_loc4_,param2);
  448.          ComputeAABB(_loc5_,param3);
  449.          param1.lowerBound.Set(_loc4_.lowerBound.x < _loc5_.lowerBound.x ? _loc4_.lowerBound.x : _loc5_.lowerBound.x,_loc4_.lowerBound.y < _loc5_.lowerBound.y ? _loc4_.lowerBound.y : _loc5_.lowerBound.y);
  450.          param1.upperBound.Set(_loc4_.upperBound.x > _loc5_.upperBound.x ? _loc4_.upperBound.x : _loc5_.upperBound.x,_loc4_.upperBound.y > _loc5_.upperBound.y ? _loc4_.upperBound.y : _loc5_.upperBound.y);
  451.       }
  452.       
  453.       public function GetVertices() : Array
  454.       {
  455.          return m_vertices;
  456.       }
  457.       
  458.       public function GetNormals() : Array
  459.       {
  460.          return m_normals;
  461.       }
  462.       
  463.       public function GetOBB() : b2OBB
  464.       {
  465.          return m_obb;
  466.       }
  467.       
  468.       public function GetFirstVertex(param1:b2XForm) : b2Vec2
  469.       {
  470.          return b2Math.b2MulX(param1,m_coreVertices[0]);
  471.       }
  472.       
  473.       public function Centroid(param1:b2XForm) : b2Vec2
  474.       {
  475.          return b2Math.b2MulX(param1,m_centroid);
  476.       }
  477.       
  478.       override public function UpdateSweepRadius(param1:b2Vec2) : void
  479.       {
  480.          var _loc2_:b2Vec2 = null;
  481.          var _loc3_:int = 0;
  482.          var _loc4_:Number = NaN;
  483.          var _loc5_:Number = NaN;
  484.          m_sweepRadius = 0;
  485.          _loc3_ = 0;
  486.          while(_loc3_ < m_vertexCount)
  487.          {
  488.             _loc2_ = m_coreVertices[_loc3_];
  489.             _loc4_ = _loc2_.x - param1.x;
  490.             _loc5_ = _loc2_.y - param1.y;
  491.             if((_loc4_ = Math.sqrt(_loc4_ * _loc4_ + _loc5_ * _loc5_)) > m_sweepRadius)
  492.             {
  493.                m_sweepRadius = _loc4_;
  494.             }
  495.             _loc3_++;
  496.          }
  497.       }
  498.       
  499.       override public function ComputeAABB(param1:b2AABB, param2:b2XForm) : void
  500.       {
  501.          var _loc3_:b2Mat22 = null;
  502.          var _loc4_:b2Vec2 = null;
  503.          var _loc5_:b2Mat22 = null;
  504.          var _loc6_:b2Mat22 = null;
  505.          var _loc7_:Number = NaN;
  506.          var _loc8_:Number = NaN;
  507.          var _loc9_:Number = NaN;
  508.          var _loc10_:Number = NaN;
  509.          _loc5_ = s_computeMat;
  510.          _loc3_ = param2.R;
  511.          _loc4_ = m_obb.R.col1;
  512.          _loc5_.col1.x = _loc3_.col1.x * _loc4_.x + _loc3_.col2.x * _loc4_.y;
  513.          _loc5_.col1.y = _loc3_.col1.y * _loc4_.x + _loc3_.col2.y * _loc4_.y;
  514.          _loc4_ = m_obb.R.col2;
  515.          _loc5_.col2.x = _loc3_.col1.x * _loc4_.x + _loc3_.col2.x * _loc4_.y;
  516.          _loc5_.col2.y = _loc3_.col1.y * _loc4_.x + _loc3_.col2.y * _loc4_.y;
  517.          _loc5_.Abs();
  518.          _loc6_ = _loc5_;
  519.          _loc4_ = m_obb.extents;
  520.          _loc7_ = _loc6_.col1.x * _loc4_.x + _loc6_.col2.x * _loc4_.y;
  521.          _loc8_ = _loc6_.col1.y * _loc4_.x + _loc6_.col2.y * _loc4_.y;
  522.          _loc3_ = param2.R;
  523.          _loc4_ = m_obb.center;
  524.          _loc9_ = param2.position.x + (_loc3_.col1.x * _loc4_.x + _loc3_.col2.x * _loc4_.y);
  525.          _loc10_ = param2.position.y + (_loc3_.col1.y * _loc4_.x + _loc3_.col2.y * _loc4_.y);
  526.          param1.lowerBound.Set(_loc9_ - _loc7_,_loc10_ - _loc8_);
  527.          param1.upperBound.Set(_loc9_ + _loc7_,_loc10_ + _loc8_);
  528.       }
  529.    }
  530. }
  531.